home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / eval.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  74KB  |  2,447 lines
  1. /* $Id: eval.c,v 3.3 1998/06/23 00:02:54 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: eval.c,v $
  26.  * Revision 3.3  1998/06/23 00:02:54  brianp
  27.  * fixed evaluator color bug (Eero Pajarre)
  28.  *
  29.  * Revision 3.2  1998/03/27 03:37:40  brianp
  30.  * fixed G++ warnings
  31.  *
  32.  * Revision 3.1  1998/02/03 00:54:15  brianp
  33.  * fixed bug in gl_copy_map_points*() functions (Sam Jordan)
  34.  *
  35.  * Revision 3.0  1998/01/31 20:51:54  brianp
  36.  * initial rev
  37.  *
  38.  */
  39.  
  40.  
  41. /*
  42.  * eval.c was written by
  43.  * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
  44.  * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
  45.  *
  46.  * My original implementation of evaluators was simplistic and didn't
  47.  * compute surface normal vectors properly.  Bernd and Volker applied
  48.  * used more sophisticated methods to get better results.
  49.  *
  50.  * Thanks guys!
  51.  */
  52.  
  53.  
  54. #ifdef PC_HEADER
  55. #include "all.h"
  56. #else
  57. #include <math.h>
  58. #include <stdlib.h>
  59. #include <string.h>
  60. #include "context.h"
  61. #include "eval.h"
  62. #include "macros.h"
  63. #include "mmath.h"
  64. #include "types.h"
  65. #include "vbfill.h"
  66. #endif
  67.  
  68.  
  69.  
  70. /*
  71.  * Do one-time initialization for evaluators.
  72.  */
  73. void gl_init_eval( void )
  74. {
  75.   static int init_flag = 0;
  76.  
  77.   /* Compute a table of nCr (combination) values used by the
  78.    * Bernstein polynomial generator.
  79.    */
  80.  
  81.   if (init_flag==0) 
  82.   { /* no initialization needed */ 
  83.   }
  84.  
  85.   init_flag = 1;
  86. }
  87.  
  88.  
  89.  
  90. /*
  91.  * Horner scheme for Bezier curves
  92.  * 
  93.  * Bezier curves can be computed via a Horner scheme.
  94.  * Horner is numerically less stable than the de Casteljau
  95.  * algorithm, but it is faster. For curves of degree n 
  96.  * the complexity of Horner is O(n) and de Casteljau is O(n^2).
  97.  * Since stability is not important for displaying curve 
  98.  * points I decided to use the Horner scheme.
  99.  *
  100.  * A cubic Bezier curve with control points b0, b1, b2, b3 can be 
  101.  * written as
  102.  *
  103.  *        (([3]        [3]     )     [3]       )     [3]
  104.  * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
  105.  *
  106.  *                                           [n]
  107.  * where s=1-t and the binomial coefficients [i]. These can 
  108.  * be computed iteratively using the identity:
  109.  *
  110.  * [n]               [n  ]             [n]
  111.  * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
  112.  */
  113.  
  114. static void
  115. horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t,
  116.                     GLuint dim, GLuint order)
  117. {
  118.   GLfloat s, powert;
  119.   GLuint i, k, bincoeff;
  120.  
  121.   if(order >= 2)
  122.   { 
  123.     bincoeff = order-1;
  124.     s = 1.0-t;
  125.  
  126.     for(k=0; k<dim; k++)
  127.       out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
  128.  
  129.     for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
  130.     {
  131.       bincoeff *= order-i;
  132.       bincoeff /= i;
  133.  
  134.       for(k=0; k<dim; k++)
  135.         out[k] = s*out[k] + bincoeff*powert*cp[k];
  136.     }
  137.   }
  138.   else /* order=1 -> constant curve */
  139.   { 
  140.     for(k=0; k<dim; k++)
  141.       out[k] = cp[k];
  142.   } 
  143. }
  144.  
  145. /*
  146.  * Tensor product Bezier surfaces
  147.  *
  148.  * Again the Horner scheme is used to compute a point on a 
  149.  * TP Bezier surface. First a control polygon for a curve
  150.  * on the surface in one parameter direction is computed,
  151.  * then the point on the curve for the other parameter 
  152.  * direction is evaluated.
  153.  *
  154.  * To store the curve control polygon additional storage
  155.  * for max(uorder,vorder) points is needed in the 
  156.  * control net cn.
  157.  */
  158.  
  159. static void
  160. horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
  161.                    GLuint dim, GLuint uorder, GLuint vorder)
  162. {
  163.   GLfloat *cp = cn + uorder*vorder*dim;
  164.   GLuint i, uinc = vorder*dim;
  165.  
  166.   if(vorder > uorder)
  167.   {
  168.     if(uorder >= 2)
  169.     { 
  170.       GLfloat s, poweru;
  171.       GLuint j, k, bincoeff;
  172.  
  173.       /* Compute the control polygon for the surface-curve in u-direction */
  174.       for(j=0; j<vorder; j++)
  175.       {
  176.         GLfloat *ucp = &cn[j*dim];
  177.  
  178.         /* Each control point is the point for parameter u on a */ 
  179.         /* curve defined by the control polygons in u-direction */
  180.     bincoeff = uorder-1;
  181.     s = 1.0-u;
  182.  
  183.     for(k=0; k<dim; k++)
  184.       cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
  185.  
  186.     for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder; 
  187.             i++, poweru*=u, ucp +=uinc)
  188.     {
  189.       bincoeff *= uorder-i;
  190.           bincoeff /= i;
  191.  
  192.       for(k=0; k<dim; k++)
  193.         cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
  194.     }
  195.       }
  196.         
  197.       /* Evaluate curve point in v */
  198.       horner_bezier_curve(cp, out, v, dim, vorder);
  199.     }
  200.     else /* uorder=1 -> cn defines a curve in v */
  201.       horner_bezier_curve(cn, out, v, dim, vorder);
  202.   }
  203.   else /* vorder <= uorder */
  204.   {
  205.     if(vorder > 1)
  206.     {
  207.       GLuint i;
  208.  
  209.       /* Compute the control polygon for the surface-curve in u-direction */
  210.       for(i=0; i<uorder; i++, cn += uinc)
  211.       {
  212.     /* For constant i all cn[i][j] (j=0..vorder) are located */
  213.     /* on consecutive memory locations, so we can use        */
  214.     /* horner_bezier_curve to compute the control points     */
  215.  
  216.     horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
  217.       }
  218.  
  219.       /* Evaluate curve point in u */
  220.       horner_bezier_curve(cp, out, u, dim, uorder);
  221.     }
  222.     else  /* vorder=1 -> cn defines a curve in u */
  223.       horner_bezier_curve(cn, out, u, dim, uorder);
  224.   }
  225. }
  226.  
  227. /*
  228.  * The direct de Casteljau algorithm is used when a point on the
  229.  * surface and the tangent directions spanning the tangent plane
  230.  * should be computed (this is needed to compute normals to the
  231.  * surface). In this case the de Casteljau algorithm approach is
  232.  * nicer because a point and the partial derivatives can be computed 
  233.  * at the same time. To get the correct tangent length du and dv
  234.  * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. 
  235.  * Since only the directions are needed, this scaling step is omitted.
  236.  *
  237.  * De Casteljau needs additional storage for uorder*vorder
  238.  * values in the control net cn.
  239.  */
  240.  
  241. static void
  242. de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
  243.                   GLfloat u, GLfloat v, GLuint dim, 
  244.                   GLuint uorder, GLuint vorder)
  245. {
  246.   GLfloat *dcn = cn + uorder*vorder*dim;
  247.   GLfloat us = 1.0-u, vs = 1.0-v;
  248.   GLuint h, i, j, k;
  249.   GLuint minorder = uorder < vorder ? uorder : vorder;
  250.   GLuint uinc = vorder*dim;
  251.   GLuint dcuinc = vorder;
  252.  
  253.   /* Each component is evaluated separately to save buffer space  */
  254.   /* This does not drasticaly decrease the performance of the     */
  255.   /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
  256.   /* points would be available, the components could be accessed  */
  257.   /* in the innermost loop which could lead to less cache misses. */
  258.  
  259. #define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] 
  260. #define DCN(I, J) dcn[(I)*dcuinc+(J)]
  261.   if(minorder < 3)
  262.   {
  263.     if(uorder==vorder)
  264.     {
  265.       for(k=0; k<dim; k++)
  266.       {
  267.     /* Derivative direction in u */
  268.     du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
  269.              v*(CN(1,1,k) - CN(0,1,k));
  270.  
  271.     /* Derivative direction in v */
  272.     dv[k] = us*(CN(0,1,k) - CN(0,0,k)) + 
  273.              u*(CN(1,1,k) - CN(1,0,k));
  274.  
  275.     /* bilinear de Casteljau step */
  276.         out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
  277.                u*(vs*CN(1,0,k) + v*CN(1,1,k));
  278.       }
  279.     }
  280.     else if(minorder == uorder)
  281.     {
  282.       for(k=0; k<dim; k++)
  283.       {
  284.     /* bilinear de Casteljau step */
  285.     DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
  286.     DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
  287.  
  288.     for(j=0; j<vorder-1; j++)
  289.     {
  290.       /* for the derivative in u */
  291.       DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
  292.       DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
  293.  
  294.       /* for the `point' */
  295.       DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
  296.       DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
  297.     }
  298.         
  299.     /* remaining linear de Casteljau steps until the second last step */
  300.     for(h=minorder; h<vorder-1; h++)
  301.       for(j=0; j<vorder-h; j++)
  302.       {
  303.         /* for the derivative in u */
  304.         DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
  305.  
  306.         /* for the `point' */
  307.         DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
  308.       }
  309.  
  310.     /* derivative direction in v */
  311.     dv[k] = DCN(0,1) - DCN(0,0);
  312.  
  313.     /* derivative direction in u */
  314.     du[k] =   vs*DCN(1,0) + v*DCN(1,1);
  315.  
  316.     /* last linear de Casteljau step */
  317.     out[k] =  vs*DCN(0,0) + v*DCN(0,1);
  318.       }
  319.     }
  320.     else /* minorder == vorder */
  321.     {
  322.       for(k=0; k<dim; k++)
  323.       {
  324.     /* bilinear de Casteljau step */
  325.     DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
  326.     DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
  327.     for(i=0; i<uorder-1; i++)
  328.     {
  329.       /* for the derivative in v */
  330.       DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
  331.       DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
  332.  
  333.       /* for the `point' */
  334.       DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
  335.       DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
  336.     }
  337.         
  338.     /* remaining linear de Casteljau steps until the second last step */
  339.     for(h=minorder; h<uorder-1; h++)
  340.       for(i=0; i<uorder-h; i++)
  341.       {
  342.         /* for the derivative in v */
  343.         DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
  344.  
  345.         /* for the `point' */
  346.         DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  347.       }
  348.  
  349.     /* derivative direction in u */
  350.     du[k] = DCN(1,0) - DCN(0,0);
  351.  
  352.     /* derivative direction in v */
  353.     dv[k] =   us*DCN(0,1) + u*DCN(1,1);
  354.  
  355.     /* last linear de Casteljau step */
  356.     out[k] =  us*DCN(0,0) + u*DCN(1,0);
  357.       }
  358.     }
  359.   }
  360.   else if(uorder == vorder)
  361.   {
  362.     for(k=0; k<dim; k++)
  363.     {
  364.       /* first bilinear de Casteljau step */
  365.       for(i=0; i<uorder-1; i++)
  366.       {
  367.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  368.     for(j=0; j<vorder-1; j++)
  369.     {
  370.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  371.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  372.     }
  373.       }
  374.  
  375.       /* remaining bilinear de Casteljau steps until the second last step */
  376.       for(h=2; h<minorder-1; h++)
  377.     for(i=0; i<uorder-h; i++)
  378.     {
  379.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  380.       for(j=0; j<vorder-h; j++)
  381.       {
  382.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  383.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  384.       }
  385.     }
  386.  
  387.       /* derivative direction in u */
  388.       du[k] = vs*(DCN(1,0) - DCN(0,0)) +
  389.            v*(DCN(1,1) - DCN(0,1));
  390.  
  391.       /* derivative direction in v */
  392.       dv[k] = us*(DCN(0,1) - DCN(0,0)) + 
  393.            u*(DCN(1,1) - DCN(1,0));
  394.  
  395.       /* last bilinear de Casteljau step */
  396.       out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
  397.              u*(vs*DCN(1,0) + v*DCN(1,1));
  398.     }
  399.   }
  400.   else if(minorder == uorder)
  401.   {
  402.     for(k=0; k<dim; k++)
  403.     {
  404.       /* first bilinear de Casteljau step */
  405.       for(i=0; i<uorder-1; i++)
  406.       {
  407.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  408.     for(j=0; j<vorder-1; j++)
  409.     {
  410.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  411.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  412.     }
  413.       }
  414.  
  415.       /* remaining bilinear de Casteljau steps until the second last step */
  416.       for(h=2; h<minorder-1; h++)
  417.     for(i=0; i<uorder-h; i++)
  418.     {
  419.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  420.       for(j=0; j<vorder-h; j++)
  421.       {
  422.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  423.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  424.       }
  425.     }
  426.  
  427.       /* last bilinear de Casteljau step */
  428.       DCN(2,0) =    DCN(1,0) -   DCN(0,0);
  429.       DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
  430.       for(j=0; j<vorder-1; j++)
  431.       {
  432.     /* for the derivative in u */
  433.     DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
  434.     DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
  435.     
  436.     /* for the `point' */
  437.     DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
  438.     DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
  439.       }
  440.         
  441.       /* remaining linear de Casteljau steps until the second last step */
  442.       for(h=minorder; h<vorder-1; h++)
  443.     for(j=0; j<vorder-h; j++)
  444.     {
  445.       /* for the derivative in u */
  446.       DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
  447.       
  448.       /* for the `point' */
  449.       DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
  450.     }
  451.       
  452.       /* derivative direction in v */
  453.       dv[k] = DCN(0,1) - DCN(0,0);
  454.       
  455.       /* derivative direction in u */
  456.       du[k] =   vs*DCN(2,0) + v*DCN(2,1);
  457.       
  458.       /* last linear de Casteljau step */
  459.       out[k] =  vs*DCN(0,0) + v*DCN(0,1);
  460.     }
  461.   }
  462.   else /* minorder == vorder */
  463.   {
  464.     for(k=0; k<dim; k++)
  465.     {
  466.       /* first bilinear de Casteljau step */
  467.       for(i=0; i<uorder-1; i++)
  468.       {
  469.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  470.     for(j=0; j<vorder-1; j++)
  471.     {
  472.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  473.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  474.     }
  475.       }
  476.  
  477.       /* remaining bilinear de Casteljau steps until the second last step */
  478.       for(h=2; h<minorder-1; h++)
  479.     for(i=0; i<uorder-h; i++)
  480.     {
  481.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  482.       for(j=0; j<vorder-h; j++)
  483.       {
  484.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  485.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  486.       }
  487.     }
  488.  
  489.       /* last bilinear de Casteljau step */
  490.       DCN(0,2) =    DCN(0,1) -   DCN(0,0);
  491.       DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
  492.       for(i=0; i<uorder-1; i++)
  493.       {
  494.     /* for the derivative in v */
  495.     DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
  496.     DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
  497.     
  498.     /* for the `point' */
  499.     DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
  500.     DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
  501.       }
  502.       
  503.       /* remaining linear de Casteljau steps until the second last step */
  504.       for(h=minorder; h<uorder-1; h++)
  505.     for(i=0; i<uorder-h; i++)
  506.     {
  507.       /* for the derivative in v */
  508.       DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
  509.       
  510.       /* for the `point' */
  511.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  512.     }
  513.       
  514.       /* derivative direction in u */
  515.       du[k] = DCN(1,0) - DCN(0,0);
  516.       
  517.       /* derivative direction in v */
  518.       dv[k] =   us*DCN(0,2) + u*DCN(1,2);
  519.       
  520.       /* last linear de Casteljau step */
  521.       out[k] =  us*DCN(0,0) + u*DCN(1,0);
  522.     }
  523.   }
  524. #undef DCN
  525. #undef CN
  526. }
  527.  
  528. /*
  529.  * Return the number of components per control point for any type of
  530.  * evaluator.  Return 0 if bad target.
  531.  */
  532.  
  533. static GLint components( GLenum target )
  534. {
  535.    switch (target) {
  536.       case GL_MAP1_VERTEX_3:        return 3;
  537.       case GL_MAP1_VERTEX_4:        return 4;
  538.       case GL_MAP1_INDEX:        return 1;
  539.       case GL_MAP1_COLOR_4:        return 4;
  540.       case GL_MAP1_NORMAL:        return 3;
  541.       case GL_MAP1_TEXTURE_COORD_1:    return 1;
  542.       case GL_MAP1_TEXTURE_COORD_2:    return 2;
  543.       case GL_MAP1_TEXTURE_COORD_3:    return 3;
  544.       case GL_MAP1_TEXTURE_COORD_4:    return 4;
  545.       case GL_MAP2_VERTEX_3:        return 3;
  546.       case GL_MAP2_VERTEX_4:        return 4;
  547.       case GL_MAP2_INDEX:        return 1;
  548.       case GL_MAP2_COLOR_4:        return 4;
  549.       case GL_MAP2_NORMAL:        return 3;
  550.       case GL_MAP2_TEXTURE_COORD_1:    return 1;
  551.       case GL_MAP2_TEXTURE_COORD_2:    return 2;
  552.       case GL_MAP2_TEXTURE_COORD_3:    return 3;
  553.       case GL_MAP2_TEXTURE_COORD_4:    return 4;
  554.       default:                return 0;
  555.    }
  556. }
  557.  
  558.  
  559. /**********************************************************************/
  560. /***            Copy and deallocate control points                  ***/
  561. /**********************************************************************/
  562.  
  563.  
  564. /*
  565.  * Copy 1-parametric evaluator control points from user-specified 
  566.  * memory space to a buffer of contiguous control points.
  567.  * Input:  see glMap1f for details
  568.  * Return:  pointer to buffer of contiguous control points or NULL if out
  569.  *          of memory.
  570.  */
  571. GLfloat *gl_copy_map_points1f( GLenum target,
  572.                                GLint ustride, GLint uorder,
  573.                                const GLfloat *points )
  574. {
  575.    GLfloat *buffer, *p;
  576.    GLint i, k, size = components(target);
  577.  
  578.    if (!points || size==0) {
  579.       return NULL;
  580.    }
  581.  
  582.    buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
  583.  
  584.    if(buffer) 
  585.       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
  586.     for(k=0; k<size; k++)
  587.       *p++ = points[k];
  588.  
  589.    return buffer;
  590. }
  591.  
  592.  
  593.  
  594. /*
  595.  * Same as above but convert doubles to floats.
  596.  */
  597. GLfloat *gl_copy_map_points1d( GLenum target,
  598.                     GLint ustride, GLint uorder,
  599.                     const GLdouble *points )
  600. {
  601.    GLfloat *buffer, *p;
  602.    GLint i, k, size = components(target);
  603.  
  604.    if (!points || size==0) {
  605.       return NULL;
  606.    }
  607.  
  608.    buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
  609.  
  610.    if(buffer)
  611.       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
  612.     for(k=0; k<size; k++)
  613.       *p++ = (GLfloat) points[k];
  614.  
  615.    return buffer;
  616. }
  617.  
  618.  
  619.  
  620. /*
  621.  * Copy 2-parametric evaluator control points from user-specified 
  622.  * memory space to a buffer of contiguous control points.
  623.  * Additional memory is allocated to be used by the horner and
  624.  * de Casteljau evaluation schemes.
  625.  *
  626.  * Input:  see glMap2f for details
  627.  * Return:  pointer to buffer of contiguous control points or NULL if out
  628.  *          of memory.
  629.  */
  630. GLfloat *gl_copy_map_points2f( GLenum target,
  631.                     GLint ustride, GLint uorder,
  632.                     GLint vstride, GLint vorder,
  633.                     const GLfloat *points )
  634. {
  635.    GLfloat *buffer, *p;
  636.    GLint i, j, k, size, dsize, hsize;
  637.    GLint uinc;
  638.  
  639.    size = components(target);
  640.  
  641.    if (!points || size==0) {
  642.       return NULL;
  643.    }
  644.  
  645.    /* max(uorder, vorder) additional points are used in      */
  646.    /* horner evaluation and uorder*vorder additional */
  647.    /* values are needed for de Casteljau                     */
  648.    dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
  649.    hsize = (uorder > vorder ? uorder : vorder)*size;
  650.  
  651.    if(hsize>dsize)
  652.      buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
  653.    else
  654.      buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
  655.  
  656.    /* compute the increment value for the u-loop */
  657.    uinc = ustride - vorder*vstride;
  658.  
  659.    if (buffer) 
  660.       for (i=0, p=buffer; i<uorder; i++, points += uinc)
  661.      for (j=0; j<vorder; j++, points += vstride)
  662.         for (k=0; k<size; k++)
  663.            *p++ = points[k];
  664.  
  665.    return buffer;
  666. }
  667.  
  668.  
  669.  
  670. /*
  671.  * Same as above but convert doubles to floats.
  672.  */
  673. GLfloat *gl_copy_map_points2d(GLenum target,
  674.                               GLint ustride, GLint uorder,
  675.                               GLint vstride, GLint vorder,
  676.                               const GLdouble *points )
  677. {
  678.    GLfloat *buffer, *p;
  679.    GLint i, j, k, size, hsize, dsize;
  680.    GLint uinc;
  681.  
  682.    size = components(target);
  683.  
  684.    if (!points || size==0) {
  685.       return NULL;
  686.    }
  687.  
  688.    /* max(uorder, vorder) additional points are used in      */
  689.    /* horner evaluation and uorder*vorder additional */
  690.    /* values are needed for de Casteljau                     */
  691.    dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
  692.    hsize = (uorder > vorder ? uorder : vorder)*size;
  693.  
  694.    if(hsize>dsize)
  695.      buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
  696.    else
  697.      buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
  698.  
  699.    /* compute the increment value for the u-loop */
  700.    uinc = ustride - vorder*vstride;
  701.  
  702.    if (buffer) 
  703.       for (i=0, p=buffer; i<uorder; i++, points += uinc)
  704.      for (j=0; j<vorder; j++, points += vstride)
  705.         for (k=0; k<size; k++)
  706.            *p++ = (GLfloat) points[k];
  707.  
  708.    return buffer;
  709. }
  710.  
  711.  
  712. /*
  713.  * This function is called by the display list deallocator function to
  714.  * specify that a given set of control points are no longer needed.
  715.  */
  716. void gl_free_control_points( GLcontext* ctx, GLenum target, GLfloat *data )
  717. {
  718.    struct gl_1d_map *map1 = NULL;
  719.    struct gl_2d_map *map2 = NULL;
  720.  
  721.    switch (target) {
  722.       case GL_MAP1_VERTEX_3:
  723.          map1 = &ctx->EvalMap.Map1Vertex3;
  724.          break;
  725.       case GL_MAP1_VERTEX_4:
  726.          map1 = &ctx->EvalMap.Map1Vertex4;
  727.      break;
  728.       case GL_MAP1_INDEX:
  729.          map1 = &ctx->EvalMap.Map1Index;
  730.          break;
  731.       case GL_MAP1_COLOR_4:
  732.          map1 = &ctx->EvalMap.Map1Color4;
  733.          break;
  734.       case GL_MAP1_NORMAL:
  735.          map1 = &ctx->EvalMap.Map1Normal;
  736.      break;
  737.       case GL_MAP1_TEXTURE_COORD_1:
  738.          map1 = &ctx->EvalMap.Map1Texture1;
  739.      break;
  740.       case GL_MAP1_TEXTURE_COORD_2:
  741.          map1 = &ctx->EvalMap.Map1Texture2;
  742.      break;
  743.       case GL_MAP1_TEXTURE_COORD_3:
  744.          map1 = &ctx->EvalMap.Map1Texture3;
  745.      break;
  746.       case GL_MAP1_TEXTURE_COORD_4:
  747.          map1 = &ctx->EvalMap.Map1Texture4;
  748.      break;
  749.       case GL_MAP2_VERTEX_3:
  750.          map2 = &ctx->EvalMap.Map2Vertex3;
  751.      break;
  752.       case GL_MAP2_VERTEX_4:
  753.          map2 = &ctx->EvalMap.Map2Vertex4;
  754.      break;
  755.       case GL_MAP2_INDEX:
  756.          map2 = &ctx->EvalMap.Map2Index;
  757.      break;
  758.       case GL_MAP2_COLOR_4:
  759.          map2 = &ctx->EvalMap.Map2Color4;
  760.          break;
  761.       case GL_MAP2_NORMAL:
  762.          map2 = &ctx->EvalMap.Map2Normal;
  763.      break;
  764.       case GL_MAP2_TEXTURE_COORD_1:
  765.          map2 = &ctx->EvalMap.Map2Texture1;
  766.      break;
  767.       case GL_MAP2_TEXTURE_COORD_2:
  768.          map2 = &ctx->EvalMap.Map2Texture2;
  769.      break;
  770.       case GL_MAP2_TEXTURE_COORD_3:
  771.          map2 = &ctx->EvalMap.Map2Texture3;
  772.      break;
  773.       case GL_MAP2_TEXTURE_COORD_4:
  774.          map2 = &ctx->EvalMap.Map2Texture4;
  775.      break;
  776.       default:
  777.      gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
  778.          return;
  779.    }
  780.  
  781.    if (map1) {
  782.       if (data==map1->Points) {
  783.          /* The control points in the display list are currently */
  784.          /* being used so we can mark them as discard-able. */
  785.          map1->Retain = GL_FALSE;
  786.       }
  787.       else {
  788.          /* The control points in the display list are not currently */
  789.          /* being used. */
  790.          free( data );
  791.       }
  792.    }
  793.    if (map2) {
  794.       if (data==map2->Points) {
  795.          /* The control points in the display list are currently */
  796.          /* being used so we can mark them as discard-able. */
  797.          map2->Retain = GL_FALSE;
  798.       }
  799.       else {
  800.          /* The control points in the display list are not currently */
  801.          /* being used. */
  802.          free( data );
  803.       }
  804.    }
  805.  
  806. }
  807.  
  808.  
  809.  
  810. /**********************************************************************/
  811. /***                      API entry points                          ***/
  812. /**********************************************************************/
  813.  
  814.  
  815. /*
  816.  * Note that the array of control points must be 'unpacked' at this time.
  817.  * Input:  retain - if TRUE, this control point data is also in a display
  818.  *                  list and can't be freed until the list is freed.
  819.  */
  820. void gl_Map1f( GLcontext* ctx, GLenum target,
  821.                GLfloat u1, GLfloat u2, GLint stride,
  822.                GLint order, const GLfloat *points, GLboolean retain )
  823. {
  824.    GLint k;
  825.  
  826.    if (!points) {
  827.       gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
  828.       return;
  829.    }
  830.  
  831.    /* may be a new stride after copying control points */
  832.    stride = components( target );
  833.  
  834.    if (INSIDE_BEGIN_END(ctx)) {
  835.       gl_error( ctx, GL_INVALID_OPERATION, "glMap1" );
  836.       return;
  837.    }
  838.  
  839.    if (u1==u2) {
  840.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
  841.       return;
  842.    }
  843.  
  844.    if (order<1 || order>MAX_EVAL_ORDER) {
  845.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
  846.       return;
  847.    }
  848.  
  849.    k = components( target );
  850.    if (k==0) {
  851.       gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
  852.    }
  853.  
  854.    if (stride < k) {
  855.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
  856.       return;
  857.    }
  858.  
  859.    switch (target) {
  860.       case GL_MAP1_VERTEX_3:
  861.          ctx->EvalMap.Map1Vertex3.Order = order;
  862.      ctx->EvalMap.Map1Vertex3.u1 = u1;
  863.      ctx->EvalMap.Map1Vertex3.u2 = u2;
  864.      if (ctx->EvalMap.Map1Vertex3.Points
  865.              && !ctx->EvalMap.Map1Vertex3.Retain) {
  866.         free( ctx->EvalMap.Map1Vertex3.Points );
  867.      }
  868.      ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
  869.          ctx->EvalMap.Map1Vertex3.Retain = retain;
  870.      break;
  871.       case GL_MAP1_VERTEX_4:
  872.          ctx->EvalMap.Map1Vertex4.Order = order;
  873.      ctx->EvalMap.Map1Vertex4.u1 = u1;
  874.      ctx->EvalMap.Map1Vertex4.u2 = u2;
  875.      if (ctx->EvalMap.Map1Vertex4.Points
  876.              && !ctx->EvalMap.Map1Vertex4.Retain) {
  877.         free( ctx->EvalMap.Map1Vertex4.Points );
  878.      }
  879.      ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
  880.      ctx->EvalMap.Map1Vertex4.Retain = retain;
  881.      break;
  882.       case GL_MAP1_INDEX:
  883.          ctx->EvalMap.Map1Index.Order = order;
  884.      ctx->EvalMap.Map1Index.u1 = u1;
  885.      ctx->EvalMap.Map1Index.u2 = u2;
  886.      if (ctx->EvalMap.Map1Index.Points
  887.              && !ctx->EvalMap.Map1Index.Retain) {
  888.         free( ctx->EvalMap.Map1Index.Points );
  889.      }
  890.      ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
  891.      ctx->EvalMap.Map1Index.Retain = retain;
  892.      break;
  893.       case GL_MAP1_COLOR_4:
  894.          ctx->EvalMap.Map1Color4.Order = order;
  895.      ctx->EvalMap.Map1Color4.u1 = u1;
  896.      ctx->EvalMap.Map1Color4.u2 = u2;
  897.      if (ctx->EvalMap.Map1Color4.Points
  898.              && !ctx->EvalMap.Map1Color4.Retain) {
  899.         free( ctx->EvalMap.Map1Color4.Points );
  900.      }
  901.      ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
  902.      ctx->EvalMap.Map1Color4.Retain = retain;
  903.      break;
  904.       case GL_MAP1_NORMAL:
  905.          ctx->EvalMap.Map1Normal.Order = order;
  906.      ctx->EvalMap.Map1Normal.u1 = u1;
  907.      ctx->EvalMap.Map1Normal.u2 = u2;
  908.      if (ctx->EvalMap.Map1Normal.Points
  909.              && !ctx->EvalMap.Map1Normal.Retain) {
  910.         free( ctx->EvalMap.Map1Normal.Points );
  911.      }
  912.      ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
  913.      ctx->EvalMap.Map1Normal.Retain = retain;
  914.      break;
  915.       case GL_MAP1_TEXTURE_COORD_1:
  916.          ctx->EvalMap.Map1Texture1.Order = order;
  917.      ctx->EvalMap.Map1Texture1.u1 = u1;
  918.      ctx->EvalMap.Map1Texture1.u2 = u2;
  919.      if (ctx->EvalMap.Map1Texture1.Points
  920.              && !ctx->EvalMap.Map1Texture1.Retain) {
  921.         free( ctx->EvalMap.Map1Texture1.Points );
  922.      }
  923.      ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
  924.      ctx->EvalMap.Map1Texture1.Retain = retain;
  925.      break;
  926.       case GL_MAP1_TEXTURE_COORD_2:
  927.          ctx->EvalMap.Map1Texture2.Order = order;
  928.      ctx->EvalMap.Map1Texture2.u1 = u1;
  929.      ctx->EvalMap.Map1Texture2.u2 = u2;
  930.      if (ctx->EvalMap.Map1Texture2.Points
  931.              && !ctx->EvalMap.Map1Texture2.Retain) {
  932.         free( ctx->EvalMap.Map1Texture2.Points );
  933.      }
  934.      ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
  935.      ctx->EvalMap.Map1Texture2.Retain = retain;
  936.      break;
  937.       case GL_MAP1_TEXTURE_COORD_3:
  938.          ctx->EvalMap.Map1Texture3.Order = order;
  939.      ctx->EvalMap.Map1Texture3.u1 = u1;
  940.      ctx->EvalMap.Map1Texture3.u2 = u2;
  941.      if (ctx->EvalMap.Map1Texture3.Points
  942.              && !ctx->EvalMap.Map1Texture3.Retain) {
  943.         free( ctx->EvalMap.Map1Texture3.Points );
  944.      }
  945.      ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
  946.      ctx->EvalMap.Map1Texture3.Retain = retain;
  947.      break;
  948.       case GL_MAP1_TEXTURE_COORD_4:
  949.          ctx->EvalMap.Map1Texture4.Order = order;
  950.      ctx->EvalMap.Map1Texture4.u1 = u1;
  951.      ctx->EvalMap.Map1Texture4.u2 = u2;
  952.      if (ctx->EvalMap.Map1Texture4.Points
  953.              && !ctx->EvalMap.Map1Texture4.Retain) {
  954.         free( ctx->EvalMap.Map1Texture4.Points );
  955.      }
  956.      ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
  957.      ctx->EvalMap.Map1Texture4.Retain = retain;
  958.      break;
  959.       default:
  960.          gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
  961.    }
  962. }
  963.  
  964.  
  965.  
  966.  
  967. /*
  968.  * Note that the array of control points must be 'unpacked' at this time.
  969.  * Input:  retain - if TRUE, this control point data is also in a display
  970.  *                  list and can't be freed until the list is freed.
  971.  */
  972. void gl_Map2f( GLcontext* ctx, GLenum target,
  973.           GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  974.           GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  975.           const GLfloat *points, GLboolean retain )
  976. {
  977.    GLint k;
  978.  
  979.    if (INSIDE_BEGIN_END(ctx)) {
  980.       gl_error( ctx, GL_INVALID_OPERATION, "glMap2" );
  981.       return;
  982.    }
  983.  
  984.    if (u1==u2) {
  985.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
  986.       return;
  987.    }
  988.  
  989.    if (v1==v2) {
  990.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
  991.       return;
  992.    }
  993.  
  994.    if (uorder<1 || uorder>MAX_EVAL_ORDER) {
  995.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
  996.       return;
  997.    }
  998.  
  999.    if (vorder<1 || vorder>MAX_EVAL_ORDER) {
  1000.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
  1001.       return;
  1002.    }
  1003.  
  1004.    k = components( target );
  1005.    if (k==0) {
  1006.       gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
  1007.    }
  1008.  
  1009.    if (ustride < k) {
  1010.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
  1011.       return;
  1012.    }
  1013.    if (vstride < k) {
  1014.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
  1015.       return;
  1016.    }
  1017.  
  1018.    switch (target) {
  1019.       case GL_MAP2_VERTEX_3:
  1020.          ctx->EvalMap.Map2Vertex3.Uorder = uorder;
  1021.      ctx->EvalMap.Map2Vertex3.u1 = u1;
  1022.      ctx->EvalMap.Map2Vertex3.u2 = u2;
  1023.          ctx->EvalMap.Map2Vertex3.Vorder = vorder;
  1024.      ctx->EvalMap.Map2Vertex3.v1 = v1;
  1025.      ctx->EvalMap.Map2Vertex3.v2 = v2;
  1026.      if (ctx->EvalMap.Map2Vertex3.Points
  1027.              && !ctx->EvalMap.Map2Vertex3.Retain) {
  1028.         free( ctx->EvalMap.Map2Vertex3.Points );
  1029.      }
  1030.      ctx->EvalMap.Map2Vertex3.Retain = retain;
  1031.      ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
  1032.      break;
  1033.       case GL_MAP2_VERTEX_4:
  1034.          ctx->EvalMap.Map2Vertex4.Uorder = uorder;
  1035.      ctx->EvalMap.Map2Vertex4.u1 = u1;
  1036.      ctx->EvalMap.Map2Vertex4.u2 = u2;
  1037.          ctx->EvalMap.Map2Vertex4.Vorder = vorder;
  1038.      ctx->EvalMap.Map2Vertex4.v1 = v1;
  1039.      ctx->EvalMap.Map2Vertex4.v2 = v2;
  1040.      if (ctx->EvalMap.Map2Vertex4.Points
  1041.              && !ctx->EvalMap.Map2Vertex4.Retain) {
  1042.         free( ctx->EvalMap.Map2Vertex4.Points );
  1043.      }
  1044.      ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
  1045.      ctx->EvalMap.Map2Vertex4.Retain = retain;
  1046.      break;
  1047.       case GL_MAP2_INDEX:
  1048.          ctx->EvalMap.Map2Index.Uorder = uorder;
  1049.      ctx->EvalMap.Map2Index.u1 = u1;
  1050.      ctx->EvalMap.Map2Index.u2 = u2;
  1051.          ctx->EvalMap.Map2Index.Vorder = vorder;
  1052.      ctx->EvalMap.Map2Index.v1 = v1;
  1053.      ctx->EvalMap.Map2Index.v2 = v2;
  1054.      if (ctx->EvalMap.Map2Index.Points
  1055.              && !ctx->EvalMap.Map2Index.Retain) {
  1056.         free( ctx->EvalMap.Map2Index.Points );
  1057.      }
  1058.      ctx->EvalMap.Map2Index.Retain = retain;
  1059.      ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
  1060.      break;
  1061.       case GL_MAP2_COLOR_4:
  1062.          ctx->EvalMap.Map2Color4.Uorder = uorder;
  1063.      ctx->EvalMap.Map2Color4.u1 = u1;
  1064.      ctx->EvalMap.Map2Color4.u2 = u2;
  1065.          ctx->EvalMap.Map2Color4.Vorder = vorder;
  1066.      ctx->EvalMap.Map2Color4.v1 = v1;
  1067.      ctx->EvalMap.Map2Color4.v2 = v2;
  1068.      if (ctx->EvalMap.Map2Color4.Points
  1069.              && !ctx->EvalMap.Map2Color4.Retain) {
  1070.         free( ctx->EvalMap.Map2Color4.Points );
  1071.      }
  1072.      ctx->EvalMap.Map2Color4.Retain = retain;
  1073.      ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
  1074.      break;
  1075.       case GL_MAP2_NORMAL:
  1076.          ctx->EvalMap.Map2Normal.Uorder = uorder;
  1077.      ctx->EvalMap.Map2Normal.u1 = u1;
  1078.      ctx->EvalMap.Map2Normal.u2 = u2;
  1079.          ctx->EvalMap.Map2Normal.Vorder = vorder;
  1080.      ctx->EvalMap.Map2Normal.v1 = v1;
  1081.      ctx->EvalMap.Map2Normal.v2 = v2;
  1082.      if (ctx->EvalMap.Map2Normal.Points
  1083.              && !ctx->EvalMap.Map2Normal.Retain) {
  1084.         free( ctx->EvalMap.Map2Normal.Points );
  1085.      }
  1086.      ctx->EvalMap.Map2Normal.Retain = retain;
  1087.      ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
  1088.      break;
  1089.       case GL_MAP2_TEXTURE_COORD_1:
  1090.          ctx->EvalMap.Map2Texture1.Uorder = uorder;
  1091.      ctx->EvalMap.Map2Texture1.u1 = u1;
  1092.      ctx->EvalMap.Map2Texture1.u2 = u2;
  1093.          ctx->EvalMap.Map2Texture1.Vorder = vorder;
  1094.      ctx->EvalMap.Map2Texture1.v1 = v1;
  1095.      ctx->EvalMap.Map2Texture1.v2 = v2;
  1096.      if (ctx->EvalMap.Map2Texture1.Points
  1097.              && !ctx->EvalMap.Map2Texture1.Retain) {
  1098.         free( ctx->EvalMap.Map2Texture1.Points );
  1099.      }
  1100.      ctx->EvalMap.Map2Texture1.Retain = retain;
  1101.      ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
  1102.      break;
  1103.       case GL_MAP2_TEXTURE_COORD_2:
  1104.          ctx->EvalMap.Map2Texture2.Uorder = uorder;
  1105.      ctx->EvalMap.Map2Texture2.u1 = u1;
  1106.      ctx->EvalMap.Map2Texture2.u2 = u2;
  1107.          ctx->EvalMap.Map2Texture2.Vorder = vorder;
  1108.      ctx->EvalMap.Map2Texture2.v1 = v1;
  1109.      ctx->EvalMap.Map2Texture2.v2 = v2;
  1110.      if (ctx->EvalMap.Map2Texture2.Points
  1111.              && !ctx->EvalMap.Map2Texture2.Retain) {
  1112.         free( ctx->EvalMap.Map2Texture2.Points );
  1113.      }
  1114.      ctx->EvalMap.Map2Texture2.Retain = retain;
  1115.      ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
  1116.      break;
  1117.       case GL_MAP2_TEXTURE_COORD_3:
  1118.          ctx->EvalMap.Map2Texture3.Uorder = uorder;
  1119.      ctx->EvalMap.Map2Texture3.u1 = u1;
  1120.      ctx->EvalMap.Map2Texture3.u2 = u2;
  1121.          ctx->EvalMap.Map2Texture3.Vorder = vorder;
  1122.      ctx->EvalMap.Map2Texture3.v1 = v1;
  1123.      ctx->EvalMap.Map2Texture3.v2 = v2;
  1124.      if (ctx->EvalMap.Map2Texture3.Points
  1125.              && !ctx->EvalMap.Map2Texture3.Retain) {
  1126.         free( ctx->EvalMap.Map2Texture3.Points );
  1127.      }
  1128.      ctx->EvalMap.Map2Texture3.Retain = retain;
  1129.      ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
  1130.      break;
  1131.       case GL_MAP2_TEXTURE_COORD_4:
  1132.          ctx->EvalMap.Map2Texture4.Uorder = uorder;
  1133.      ctx->EvalMap.Map2Texture4.u1 = u1;
  1134.      ctx->EvalMap.Map2Texture4.u2 = u2;
  1135.          ctx->EvalMap.Map2Texture4.Vorder = vorder;
  1136.      ctx->EvalMap.Map2Texture4.v1 = v1;
  1137.      ctx->EvalMap.Map2Texture4.v2 = v2;
  1138.      if (ctx->EvalMap.Map2Texture4.Points
  1139.              && !ctx->EvalMap.Map2Texture4.Retain) {
  1140.         free( ctx->EvalMap.Map2Texture4.Points );
  1141.      }
  1142.      ctx->EvalMap.Map2Texture4.Retain = retain;
  1143.      ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
  1144.      break;
  1145.       default:
  1146.          gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
  1147.    }
  1148. }
  1149.  
  1150.  
  1151.    
  1152.  
  1153.  
  1154. void gl_GetMapdv( GLcontext* ctx, GLenum target, GLenum query, GLdouble *v )
  1155. {
  1156.    GLint i, n;
  1157.    GLfloat *data;
  1158.  
  1159.    switch (query) {
  1160.       case GL_COEFF:
  1161.      switch (target) {
  1162.         case GL_MAP1_COLOR_4:
  1163.            data = ctx->EvalMap.Map1Color4.Points;
  1164.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1165.            break;
  1166.         case GL_MAP1_INDEX:
  1167.            data = ctx->EvalMap.Map1Index.Points;
  1168.            n = ctx->EvalMap.Map1Index.Order;
  1169.            break;
  1170.         case GL_MAP1_NORMAL:
  1171.            data = ctx->EvalMap.Map1Normal.Points;
  1172.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1173.            break;
  1174.         case GL_MAP1_TEXTURE_COORD_1:
  1175.            data = ctx->EvalMap.Map1Texture1.Points;
  1176.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1177.            break;
  1178.         case GL_MAP1_TEXTURE_COORD_2:
  1179.            data = ctx->EvalMap.Map1Texture2.Points;
  1180.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1181.            break;
  1182.         case GL_MAP1_TEXTURE_COORD_3:
  1183.            data = ctx->EvalMap.Map1Texture3.Points;
  1184.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1185.            break;
  1186.         case GL_MAP1_TEXTURE_COORD_4:
  1187.            data = ctx->EvalMap.Map1Texture4.Points;
  1188.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1189.            break;
  1190.         case GL_MAP1_VERTEX_3:
  1191.            data = ctx->EvalMap.Map1Vertex3.Points;
  1192.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1193.            break;
  1194.         case GL_MAP1_VERTEX_4:
  1195.            data = ctx->EvalMap.Map1Vertex4.Points;
  1196.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1197.            break;
  1198.         case GL_MAP2_COLOR_4:
  1199.            data = ctx->EvalMap.Map2Color4.Points;
  1200.            n = ctx->EvalMap.Map2Color4.Uorder
  1201.                  * ctx->EvalMap.Map2Color4.Vorder * 4;
  1202.            break;
  1203.         case GL_MAP2_INDEX:
  1204.            data = ctx->EvalMap.Map2Index.Points;
  1205.            n = ctx->EvalMap.Map2Index.Uorder
  1206.                  * ctx->EvalMap.Map2Index.Vorder;
  1207.            break;
  1208.         case GL_MAP2_NORMAL:
  1209.            data = ctx->EvalMap.Map2Normal.Points;
  1210.            n = ctx->EvalMap.Map2Normal.Uorder
  1211.                  * ctx->EvalMap.Map2Normal.Vorder * 3;
  1212.            break;
  1213.         case GL_MAP2_TEXTURE_COORD_1:
  1214.            data = ctx->EvalMap.Map2Texture1.Points;
  1215.            n = ctx->EvalMap.Map2Texture1.Uorder
  1216.                  * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1217.            break;
  1218.         case GL_MAP2_TEXTURE_COORD_2:
  1219.            data = ctx->EvalMap.Map2Texture2.Points;
  1220.            n = ctx->EvalMap.Map2Texture2.Uorder
  1221.                  * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1222.            break;
  1223.         case GL_MAP2_TEXTURE_COORD_3:
  1224.            data = ctx->EvalMap.Map2Texture3.Points;
  1225.            n = ctx->EvalMap.Map2Texture3.Uorder
  1226.                  * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1227.            break;
  1228.         case GL_MAP2_TEXTURE_COORD_4:
  1229.            data = ctx->EvalMap.Map2Texture4.Points;
  1230.            n = ctx->EvalMap.Map2Texture4.Uorder
  1231.                  * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1232.            break;
  1233.         case GL_MAP2_VERTEX_3:
  1234.            data = ctx->EvalMap.Map2Vertex3.Points;
  1235.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1236.                  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1237.            break;
  1238.         case GL_MAP2_VERTEX_4:
  1239.            data = ctx->EvalMap.Map2Vertex4.Points;
  1240.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1241.                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1242.            break;
  1243.         default:
  1244.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1245.      }
  1246.      if (data) {
  1247.         for (i=0;i<n;i++) {
  1248.            v[i] = data[i];
  1249.         }
  1250.      }
  1251.          break;
  1252.       case GL_ORDER:
  1253.      switch (target) {
  1254.         case GL_MAP1_COLOR_4:
  1255.            *v = ctx->EvalMap.Map1Color4.Order;
  1256.            break;
  1257.         case GL_MAP1_INDEX:
  1258.            *v = ctx->EvalMap.Map1Index.Order;
  1259.            break;
  1260.         case GL_MAP1_NORMAL:
  1261.            *v = ctx->EvalMap.Map1Normal.Order;
  1262.            break;
  1263.         case GL_MAP1_TEXTURE_COORD_1:
  1264.            *v = ctx->EvalMap.Map1Texture1.Order;
  1265.            break;
  1266.         case GL_MAP1_TEXTURE_COORD_2:
  1267.            *v = ctx->EvalMap.Map1Texture2.Order;
  1268.            break;
  1269.         case GL_MAP1_TEXTURE_COORD_3:
  1270.            *v = ctx->EvalMap.Map1Texture3.Order;
  1271.            break;
  1272.         case GL_MAP1_TEXTURE_COORD_4:
  1273.            *v = ctx->EvalMap.Map1Texture4.Order;
  1274.            break;
  1275.         case GL_MAP1_VERTEX_3:
  1276.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1277.            break;
  1278.         case GL_MAP1_VERTEX_4:
  1279.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1280.            break;
  1281.         case GL_MAP2_COLOR_4:
  1282.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1283.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1284.            break;
  1285.         case GL_MAP2_INDEX:
  1286.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1287.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1288.            break;
  1289.         case GL_MAP2_NORMAL:
  1290.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1291.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1292.            break;
  1293.         case GL_MAP2_TEXTURE_COORD_1:
  1294.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1295.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1296.            break;
  1297.         case GL_MAP2_TEXTURE_COORD_2:
  1298.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1299.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1300.            break;
  1301.         case GL_MAP2_TEXTURE_COORD_3:
  1302.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1303.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1304.            break;
  1305.         case GL_MAP2_TEXTURE_COORD_4:
  1306.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1307.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1308.            break;
  1309.         case GL_MAP2_VERTEX_3:
  1310.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1311.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1312.            break;
  1313.         case GL_MAP2_VERTEX_4:
  1314.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1315.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1316.            break;
  1317.         default:
  1318.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1319.      }
  1320.          break;
  1321.       case GL_DOMAIN:
  1322.      switch (target) {
  1323.         case GL_MAP1_COLOR_4:
  1324.            v[0] = ctx->EvalMap.Map1Color4.u1;
  1325.            v[1] = ctx->EvalMap.Map1Color4.u2;
  1326.            break;
  1327.         case GL_MAP1_INDEX:
  1328.            v[0] = ctx->EvalMap.Map1Index.u1;
  1329.            v[1] = ctx->EvalMap.Map1Index.u2;
  1330.            break;
  1331.         case GL_MAP1_NORMAL:
  1332.            v[0] = ctx->EvalMap.Map1Normal.u1;
  1333.            v[1] = ctx->EvalMap.Map1Normal.u2;
  1334.            break;
  1335.         case GL_MAP1_TEXTURE_COORD_1:
  1336.            v[0] = ctx->EvalMap.Map1Texture1.u1;
  1337.            v[1] = ctx->EvalMap.Map1Texture1.u2;
  1338.            break;
  1339.         case GL_MAP1_TEXTURE_COORD_2:
  1340.            v[0] = ctx->EvalMap.Map1Texture2.u1;
  1341.            v[1] = ctx->EvalMap.Map1Texture2.u2;
  1342.            break;
  1343.         case GL_MAP1_TEXTURE_COORD_3:
  1344.            v[0] = ctx->EvalMap.Map1Texture3.u1;
  1345.            v[1] = ctx->EvalMap.Map1Texture3.u2;
  1346.            break;
  1347.         case GL_MAP1_TEXTURE_COORD_4:
  1348.            v[0] = ctx->EvalMap.Map1Texture4.u1;
  1349.            v[1] = ctx->EvalMap.Map1Texture4.u2;
  1350.            break;
  1351.         case GL_MAP1_VERTEX_3:
  1352.            v[0] = ctx->EvalMap.Map1Vertex3.u1;
  1353.            v[1] = ctx->EvalMap.Map1Vertex3.u2;
  1354.            break;
  1355.         case GL_MAP1_VERTEX_4:
  1356.            v[0] = ctx->EvalMap.Map1Vertex4.u1;
  1357.            v[1] = ctx->EvalMap.Map1Vertex4.u2;
  1358.            break;
  1359.         case GL_MAP2_COLOR_4:
  1360.            v[0] = ctx->EvalMap.Map2Color4.u1;
  1361.            v[1] = ctx->EvalMap.Map2Color4.u2;
  1362.            v[2] = ctx->EvalMap.Map2Color4.v1;
  1363.            v[3] = ctx->EvalMap.Map2Color4.v2;
  1364.            break;
  1365.         case GL_MAP2_INDEX:
  1366.            v[0] = ctx->EvalMap.Map2Index.u1;
  1367.            v[1] = ctx->EvalMap.Map2Index.u2;
  1368.            v[2] = ctx->EvalMap.Map2Index.v1;
  1369.            v[3] = ctx->EvalMap.Map2Index.v2;
  1370.            break;
  1371.         case GL_MAP2_NORMAL:
  1372.            v[0] = ctx->EvalMap.Map2Normal.u1;
  1373.            v[1] = ctx->EvalMap.Map2Normal.u2;
  1374.            v[2] = ctx->EvalMap.Map2Normal.v1;
  1375.            v[3] = ctx->EvalMap.Map2Normal.v2;
  1376.            break;
  1377.         case GL_MAP2_TEXTURE_COORD_1:
  1378.            v[0] = ctx->EvalMap.Map2Texture1.u1;
  1379.            v[1] = ctx->EvalMap.Map2Texture1.u2;
  1380.            v[2] = ctx->EvalMap.Map2Texture1.v1;
  1381.            v[3] = ctx->EvalMap.Map2Texture1.v2;
  1382.            break;
  1383.         case GL_MAP2_TEXTURE_COORD_2:
  1384.            v[0] = ctx->EvalMap.Map2Texture2.u1;
  1385.            v[1] = ctx->EvalMap.Map2Texture2.u2;
  1386.            v[2] = ctx->EvalMap.Map2Texture2.v1;
  1387.            v[3] = ctx->EvalMap.Map2Texture2.v2;
  1388.            break;
  1389.         case GL_MAP2_TEXTURE_COORD_3:
  1390.            v[0] = ctx->EvalMap.Map2Texture3.u1;
  1391.            v[1] = ctx->EvalMap.Map2Texture3.u2;
  1392.            v[2] = ctx->EvalMap.Map2Texture3.v1;
  1393.            v[3] = ctx->EvalMap.Map2Texture3.v2;
  1394.            break;
  1395.         case GL_MAP2_TEXTURE_COORD_4:
  1396.            v[0] = ctx->EvalMap.Map2Texture4.u1;
  1397.            v[1] = ctx->EvalMap.Map2Texture4.u2;
  1398.            v[2] = ctx->EvalMap.Map2Texture4.v1;
  1399.            v[3] = ctx->EvalMap.Map2Texture4.v2;
  1400.            break;
  1401.         case GL_MAP2_VERTEX_3:
  1402.            v[0] = ctx->EvalMap.Map2Vertex3.u1;
  1403.            v[1] = ctx->EvalMap.Map2Vertex3.u2;
  1404.            v[2] = ctx->EvalMap.Map2Vertex3.v1;
  1405.            v[3] = ctx->EvalMap.Map2Vertex3.v2;
  1406.            break;
  1407.         case GL_MAP2_VERTEX_4:
  1408.            v[0] = ctx->EvalMap.Map2Vertex4.u1;
  1409.            v[1] = ctx->EvalMap.Map2Vertex4.u2;
  1410.            v[2] = ctx->EvalMap.Map2Vertex4.v1;
  1411.            v[3] = ctx->EvalMap.Map2Vertex4.v2;
  1412.            break;
  1413.         default:
  1414.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1415.      }
  1416.          break;
  1417.       default:
  1418.          gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
  1419.    }
  1420. }
  1421.  
  1422.  
  1423. void gl_GetMapfv( GLcontext* ctx, GLenum target, GLenum query, GLfloat *v )
  1424. {
  1425.    GLint i, n;
  1426.    GLfloat *data;
  1427.  
  1428.    switch (query) {
  1429.       case GL_COEFF:
  1430.      switch (target) {
  1431.         case GL_MAP1_COLOR_4:
  1432.            data = ctx->EvalMap.Map1Color4.Points;
  1433.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1434.            break;
  1435.         case GL_MAP1_INDEX:
  1436.            data = ctx->EvalMap.Map1Index.Points;
  1437.            n = ctx->EvalMap.Map1Index.Order;
  1438.            break;
  1439.         case GL_MAP1_NORMAL:
  1440.            data = ctx->EvalMap.Map1Normal.Points;
  1441.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1442.            break;
  1443.         case GL_MAP1_TEXTURE_COORD_1:
  1444.            data = ctx->EvalMap.Map1Texture1.Points;
  1445.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1446.            break;
  1447.         case GL_MAP1_TEXTURE_COORD_2:
  1448.            data = ctx->EvalMap.Map1Texture2.Points;
  1449.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1450.            break;
  1451.         case GL_MAP1_TEXTURE_COORD_3:
  1452.            data = ctx->EvalMap.Map1Texture3.Points;
  1453.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1454.            break;
  1455.         case GL_MAP1_TEXTURE_COORD_4:
  1456.            data = ctx->EvalMap.Map1Texture4.Points;
  1457.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1458.            break;
  1459.         case GL_MAP1_VERTEX_3:
  1460.            data = ctx->EvalMap.Map1Vertex3.Points;
  1461.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1462.            break;
  1463.         case GL_MAP1_VERTEX_4:
  1464.            data = ctx->EvalMap.Map1Vertex4.Points;
  1465.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1466.            break;
  1467.         case GL_MAP2_COLOR_4:
  1468.            data = ctx->EvalMap.Map2Color4.Points;
  1469.            n = ctx->EvalMap.Map2Color4.Uorder
  1470.                  * ctx->EvalMap.Map2Color4.Vorder * 4;
  1471.            break;
  1472.         case GL_MAP2_INDEX:
  1473.            data = ctx->EvalMap.Map2Index.Points;
  1474.            n = ctx->EvalMap.Map2Index.Uorder
  1475.                  * ctx->EvalMap.Map2Index.Vorder;
  1476.            break;
  1477.         case GL_MAP2_NORMAL:
  1478.            data = ctx->EvalMap.Map2Normal.Points;
  1479.            n = ctx->EvalMap.Map2Normal.Uorder
  1480.                  * ctx->EvalMap.Map2Normal.Vorder * 3;
  1481.            break;
  1482.         case GL_MAP2_TEXTURE_COORD_1:
  1483.            data = ctx->EvalMap.Map2Texture1.Points;
  1484.            n = ctx->EvalMap.Map2Texture1.Uorder
  1485.                  * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1486.            break;
  1487.         case GL_MAP2_TEXTURE_COORD_2:
  1488.            data = ctx->EvalMap.Map2Texture2.Points;
  1489.            n = ctx->EvalMap.Map2Texture2.Uorder
  1490.                  * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1491.            break;
  1492.         case GL_MAP2_TEXTURE_COORD_3:
  1493.            data = ctx->EvalMap.Map2Texture3.Points;
  1494.            n = ctx->EvalMap.Map2Texture3.Uorder
  1495.                  * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1496.            break;
  1497.         case GL_MAP2_TEXTURE_COORD_4:
  1498.            data = ctx->EvalMap.Map2Texture4.Points;
  1499.            n = ctx->EvalMap.Map2Texture4.Uorder
  1500.                  * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1501.            break;
  1502.         case GL_MAP2_VERTEX_3:
  1503.            data = ctx->EvalMap.Map2Vertex3.Points;
  1504.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1505.                  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1506.            break;
  1507.         case GL_MAP2_VERTEX_4:
  1508.            data = ctx->EvalMap.Map2Vertex4.Points;
  1509.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1510.                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1511.            break;
  1512.         default:
  1513.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1514.      }
  1515.      if (data) {
  1516.         for (i=0;i<n;i++) {
  1517.            v[i] = data[i];
  1518.         }
  1519.      }
  1520.          break;
  1521.       case GL_ORDER:
  1522.      switch (target) {
  1523.         case GL_MAP1_COLOR_4:
  1524.            *v = ctx->EvalMap.Map1Color4.Order;
  1525.            break;
  1526.         case GL_MAP1_INDEX:
  1527.            *v = ctx->EvalMap.Map1Index.Order;
  1528.            break;
  1529.         case GL_MAP1_NORMAL:
  1530.            *v = ctx->EvalMap.Map1Normal.Order;
  1531.            break;
  1532.         case GL_MAP1_TEXTURE_COORD_1:
  1533.            *v = ctx->EvalMap.Map1Texture1.Order;
  1534.            break;
  1535.         case GL_MAP1_TEXTURE_COORD_2:
  1536.            *v = ctx->EvalMap.Map1Texture2.Order;
  1537.            break;
  1538.         case GL_MAP1_TEXTURE_COORD_3:
  1539.            *v = ctx->EvalMap.Map1Texture3.Order;
  1540.            break;
  1541.         case GL_MAP1_TEXTURE_COORD_4:
  1542.            *v = ctx->EvalMap.Map1Texture4.Order;
  1543.            break;
  1544.         case GL_MAP1_VERTEX_3:
  1545.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1546.            break;
  1547.         case GL_MAP1_VERTEX_4:
  1548.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1549.            break;
  1550.         case GL_MAP2_COLOR_4:
  1551.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1552.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1553.            break;
  1554.         case GL_MAP2_INDEX:
  1555.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1556.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1557.            break;
  1558.         case GL_MAP2_NORMAL:
  1559.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1560.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1561.            break;
  1562.         case GL_MAP2_TEXTURE_COORD_1:
  1563.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1564.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1565.            break;
  1566.         case GL_MAP2_TEXTURE_COORD_2:
  1567.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1568.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1569.            break;
  1570.         case GL_MAP2_TEXTURE_COORD_3:
  1571.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1572.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1573.            break;
  1574.         case GL_MAP2_TEXTURE_COORD_4:
  1575.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1576.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1577.            break;
  1578.         case GL_MAP2_VERTEX_3:
  1579.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1580.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1581.            break;
  1582.         case GL_MAP2_VERTEX_4:
  1583.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1584.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1585.            break;
  1586.         default:
  1587.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1588.      }
  1589.          break;
  1590.       case GL_DOMAIN:
  1591.      switch (target) {
  1592.         case GL_MAP1_COLOR_4:
  1593.            v[0] = ctx->EvalMap.Map1Color4.u1;
  1594.            v[1] = ctx->EvalMap.Map1Color4.u2;
  1595.            break;
  1596.         case GL_MAP1_INDEX:
  1597.            v[0] = ctx->EvalMap.Map1Index.u1;
  1598.            v[1] = ctx->EvalMap.Map1Index.u2;
  1599.            break;
  1600.         case GL_MAP1_NORMAL:
  1601.            v[0] = ctx->EvalMap.Map1Normal.u1;
  1602.            v[1] = ctx->EvalMap.Map1Normal.u2;
  1603.            break;
  1604.         case GL_MAP1_TEXTURE_COORD_1:
  1605.            v[0] = ctx->EvalMap.Map1Texture1.u1;
  1606.            v[1] = ctx->EvalMap.Map1Texture1.u2;
  1607.            break;
  1608.         case GL_MAP1_TEXTURE_COORD_2:
  1609.            v[0] = ctx->EvalMap.Map1Texture2.u1;
  1610.            v[1] = ctx->EvalMap.Map1Texture2.u2;
  1611.            break;
  1612.         case GL_MAP1_TEXTURE_COORD_3:
  1613.            v[0] = ctx->EvalMap.Map1Texture3.u1;
  1614.            v[1] = ctx->EvalMap.Map1Texture3.u2;
  1615.            break;
  1616.         case GL_MAP1_TEXTURE_COORD_4:
  1617.            v[0] = ctx->EvalMap.Map1Texture4.u1;
  1618.            v[1] = ctx->EvalMap.Map1Texture4.u2;
  1619.            break;
  1620.         case GL_MAP1_VERTEX_3:
  1621.            v[0] = ctx->EvalMap.Map1Vertex3.u1;
  1622.            v[1] = ctx->EvalMap.Map1Vertex3.u2;
  1623.            break;
  1624.         case GL_MAP1_VERTEX_4:
  1625.            v[0] = ctx->EvalMap.Map1Vertex4.u1;
  1626.            v[1] = ctx->EvalMap.Map1Vertex4.u2;
  1627.            break;
  1628.         case GL_MAP2_COLOR_4:
  1629.            v[0] = ctx->EvalMap.Map2Color4.u1;
  1630.            v[1] = ctx->EvalMap.Map2Color4.u2;
  1631.            v[2] = ctx->EvalMap.Map2Color4.v1;
  1632.            v[3] = ctx->EvalMap.Map2Color4.v2;
  1633.            break;
  1634.         case GL_MAP2_INDEX:
  1635.            v[0] = ctx->EvalMap.Map2Index.u1;
  1636.            v[1] = ctx->EvalMap.Map2Index.u2;
  1637.            v[2] = ctx->EvalMap.Map2Index.v1;
  1638.            v[3] = ctx->EvalMap.Map2Index.v2;
  1639.            break;
  1640.         case GL_MAP2_NORMAL:
  1641.            v[0] = ctx->EvalMap.Map2Normal.u1;
  1642.            v[1] = ctx->EvalMap.Map2Normal.u2;
  1643.            v[2] = ctx->EvalMap.Map2Normal.v1;
  1644.            v[3] = ctx->EvalMap.Map2Normal.v2;
  1645.            break;
  1646.         case GL_MAP2_TEXTURE_COORD_1:
  1647.            v[0] = ctx->EvalMap.Map2Texture1.u1;
  1648.            v[1] = ctx->EvalMap.Map2Texture1.u2;
  1649.            v[2] = ctx->EvalMap.Map2Texture1.v1;
  1650.            v[3] = ctx->EvalMap.Map2Texture1.v2;
  1651.            break;
  1652.         case GL_MAP2_TEXTURE_COORD_2:
  1653.            v[0] = ctx->EvalMap.Map2Texture2.u1;
  1654.            v[1] = ctx->EvalMap.Map2Texture2.u2;
  1655.            v[2] = ctx->EvalMap.Map2Texture2.v1;
  1656.            v[3] = ctx->EvalMap.Map2Texture2.v2;
  1657.            break;
  1658.         case GL_MAP2_TEXTURE_COORD_3:
  1659.            v[0] = ctx->EvalMap.Map2Texture3.u1;
  1660.            v[1] = ctx->EvalMap.Map2Texture3.u2;
  1661.            v[2] = ctx->EvalMap.Map2Texture3.v1;
  1662.            v[3] = ctx->EvalMap.Map2Texture3.v2;
  1663.            break;
  1664.         case GL_MAP2_TEXTURE_COORD_4:
  1665.            v[0] = ctx->EvalMap.Map2Texture4.u1;
  1666.            v[1] = ctx->EvalMap.Map2Texture4.u2;
  1667.            v[2] = ctx->EvalMap.Map2Texture4.v1;
  1668.            v[3] = ctx->EvalMap.Map2Texture4.v2;
  1669.            break;
  1670.         case GL_MAP2_VERTEX_3:
  1671.            v[0] = ctx->EvalMap.Map2Vertex3.u1;
  1672.            v[1] = ctx->EvalMap.Map2Vertex3.u2;
  1673.            v[2] = ctx->EvalMap.Map2Vertex3.v1;
  1674.            v[3] = ctx->EvalMap.Map2Vertex3.v2;
  1675.            break;
  1676.         case GL_MAP2_VERTEX_4:
  1677.            v[0] = ctx->EvalMap.Map2Vertex4.u1;
  1678.            v[1] = ctx->EvalMap.Map2Vertex4.u2;
  1679.            v[2] = ctx->EvalMap.Map2Vertex4.v1;
  1680.            v[3] = ctx->EvalMap.Map2Vertex4.v2;
  1681.            break;
  1682.         default:
  1683.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1684.      }
  1685.          break;
  1686.       default:
  1687.          gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
  1688.    }
  1689. }
  1690.  
  1691.  
  1692. void gl_GetMapiv( GLcontext* ctx, GLenum target, GLenum query, GLint *v )
  1693. {
  1694.    GLuint i, n;
  1695.    GLfloat *data;
  1696.  
  1697.    switch (query) {
  1698.       case GL_COEFF:
  1699.      switch (target) {
  1700.         case GL_MAP1_COLOR_4:
  1701.            data = ctx->EvalMap.Map1Color4.Points;
  1702.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1703.            break;
  1704.         case GL_MAP1_INDEX:
  1705.            data = ctx->EvalMap.Map1Index.Points;
  1706.            n = ctx->EvalMap.Map1Index.Order;
  1707.            break;
  1708.         case GL_MAP1_NORMAL:
  1709.            data = ctx->EvalMap.Map1Normal.Points;
  1710.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1711.            break;
  1712.         case GL_MAP1_TEXTURE_COORD_1:
  1713.            data = ctx->EvalMap.Map1Texture1.Points;
  1714.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1715.            break;
  1716.         case GL_MAP1_TEXTURE_COORD_2:
  1717.            data = ctx->EvalMap.Map1Texture2.Points;
  1718.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1719.            break;
  1720.         case GL_MAP1_TEXTURE_COORD_3:
  1721.            data = ctx->EvalMap.Map1Texture3.Points;
  1722.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1723.            break;
  1724.         case GL_MAP1_TEXTURE_COORD_4:
  1725.            data = ctx->EvalMap.Map1Texture4.Points;
  1726.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1727.            break;
  1728.         case GL_MAP1_VERTEX_3:
  1729.            data = ctx->EvalMap.Map1Vertex3.Points;
  1730.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1731.            break;
  1732.         case GL_MAP1_VERTEX_4:
  1733.            data = ctx->EvalMap.Map1Vertex4.Points;
  1734.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1735.            break;
  1736.         case GL_MAP2_COLOR_4:
  1737.            data = ctx->EvalMap.Map2Color4.Points;
  1738.            n = ctx->EvalMap.Map2Color4.Uorder
  1739.                  * ctx->EvalMap.Map2Color4.Vorder * 4;
  1740.            break;
  1741.         case GL_MAP2_INDEX:
  1742.            data = ctx->EvalMap.Map2Index.Points;
  1743.            n = ctx->EvalMap.Map2Index.Uorder
  1744.                  * ctx->EvalMap.Map2Index.Vorder;
  1745.            break;
  1746.         case GL_MAP2_NORMAL:
  1747.            data = ctx->EvalMap.Map2Normal.Points;
  1748.            n = ctx->EvalMap.Map2Normal.Uorder
  1749.                  * ctx->EvalMap.Map2Normal.Vorder * 3;
  1750.            break;
  1751.         case GL_MAP2_TEXTURE_COORD_1:
  1752.            data = ctx->EvalMap.Map2Texture1.Points;
  1753.            n = ctx->EvalMap.Map2Texture1.Uorder
  1754.                  * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1755.            break;
  1756.         case GL_MAP2_TEXTURE_COORD_2:
  1757.            data = ctx->EvalMap.Map2Texture2.Points;
  1758.            n = ctx->EvalMap.Map2Texture2.Uorder
  1759.                  * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1760.            break;
  1761.         case GL_MAP2_TEXTURE_COORD_3:
  1762.            data = ctx->EvalMap.Map2Texture3.Points;
  1763.            n = ctx->EvalMap.Map2Texture3.Uorder
  1764.                  * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1765.            break;
  1766.         case GL_MAP2_TEXTURE_COORD_4:
  1767.            data = ctx->EvalMap.Map2Texture4.Points;
  1768.            n = ctx->EvalMap.Map2Texture4.Uorder
  1769.                  * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1770.            break;
  1771.         case GL_MAP2_VERTEX_3:
  1772.            data = ctx->EvalMap.Map2Vertex3.Points;
  1773.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1774.                  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1775.            break;
  1776.         case GL_MAP2_VERTEX_4:
  1777.            data = ctx->EvalMap.Map2Vertex4.Points;
  1778.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1779.                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1780.            break;
  1781.         default:
  1782.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1783.      }
  1784.      if (data) {
  1785.         for (i=0;i<n;i++) {
  1786.            v[i] = ROUNDF(data[i]);
  1787.         }
  1788.      }
  1789.          break;
  1790.       case GL_ORDER:
  1791.      switch (target) {
  1792.         case GL_MAP1_COLOR_4:
  1793.            *v = ctx->EvalMap.Map1Color4.Order;
  1794.            break;
  1795.         case GL_MAP1_INDEX:
  1796.            *v = ctx->EvalMap.Map1Index.Order;
  1797.            break;
  1798.         case GL_MAP1_NORMAL:
  1799.            *v = ctx->EvalMap.Map1Normal.Order;
  1800.            break;
  1801.         case GL_MAP1_TEXTURE_COORD_1:
  1802.            *v = ctx->EvalMap.Map1Texture1.Order;
  1803.            break;
  1804.         case GL_MAP1_TEXTURE_COORD_2:
  1805.            *v = ctx->EvalMap.Map1Texture2.Order;
  1806.            break;
  1807.         case GL_MAP1_TEXTURE_COORD_3:
  1808.            *v = ctx->EvalMap.Map1Texture3.Order;
  1809.            break;
  1810.         case GL_MAP1_TEXTURE_COORD_4:
  1811.            *v = ctx->EvalMap.Map1Texture4.Order;
  1812.            break;
  1813.         case GL_MAP1_VERTEX_3:
  1814.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1815.            break;
  1816.         case GL_MAP1_VERTEX_4:
  1817.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1818.            break;
  1819.         case GL_MAP2_COLOR_4:
  1820.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1821.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1822.            break;
  1823.         case GL_MAP2_INDEX:
  1824.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1825.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1826.            break;
  1827.         case GL_MAP2_NORMAL:
  1828.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1829.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1830.            break;
  1831.         case GL_MAP2_TEXTURE_COORD_1:
  1832.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1833.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1834.            break;
  1835.         case GL_MAP2_TEXTURE_COORD_2:
  1836.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1837.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1838.            break;
  1839.         case GL_MAP2_TEXTURE_COORD_3:
  1840.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1841.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1842.            break;
  1843.         case GL_MAP2_TEXTURE_COORD_4:
  1844.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1845.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1846.            break;
  1847.         case GL_MAP2_VERTEX_3:
  1848.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1849.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1850.            break;
  1851.         case GL_MAP2_VERTEX_4:
  1852.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1853.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1854.            break;
  1855.         default:
  1856.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1857.      }
  1858.          break;
  1859.       case GL_DOMAIN:
  1860.      switch (target) {
  1861.         case GL_MAP1_COLOR_4:
  1862.            v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
  1863.            v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
  1864.            break;
  1865.         case GL_MAP1_INDEX:
  1866.            v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
  1867.            v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
  1868.            break;
  1869.         case GL_MAP1_NORMAL:
  1870.            v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
  1871.            v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
  1872.            break;
  1873.         case GL_MAP1_TEXTURE_COORD_1:
  1874.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
  1875.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
  1876.            break;
  1877.         case GL_MAP1_TEXTURE_COORD_2:
  1878.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
  1879.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
  1880.            break;
  1881.         case GL_MAP1_TEXTURE_COORD_3:
  1882.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
  1883.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
  1884.            break;
  1885.         case GL_MAP1_TEXTURE_COORD_4:
  1886.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
  1887.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
  1888.            break;
  1889.         case GL_MAP1_VERTEX_3:
  1890.            v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
  1891.            v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
  1892.            break;
  1893.         case GL_MAP1_VERTEX_4:
  1894.            v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
  1895.            v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
  1896.            break;
  1897.         case GL_MAP2_COLOR_4:
  1898.            v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
  1899.            v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
  1900.            v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
  1901.            v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
  1902.            break;
  1903.         case GL_MAP2_INDEX:
  1904.            v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
  1905.            v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
  1906.            v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
  1907.            v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
  1908.            break;
  1909.         case GL_MAP2_NORMAL:
  1910.            v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
  1911.            v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
  1912.            v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
  1913.            v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
  1914.            break;
  1915.         case GL_MAP2_TEXTURE_COORD_1:
  1916.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
  1917.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
  1918.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
  1919.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
  1920.            break;
  1921.         case GL_MAP2_TEXTURE_COORD_2:
  1922.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
  1923.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
  1924.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
  1925.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
  1926.            break;
  1927.         case GL_MAP2_TEXTURE_COORD_3:
  1928.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
  1929.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
  1930.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
  1931.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
  1932.            break;
  1933.         case GL_MAP2_TEXTURE_COORD_4:
  1934.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
  1935.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
  1936.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
  1937.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
  1938.            break;
  1939.         case GL_MAP2_VERTEX_3:
  1940.            v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
  1941.            v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
  1942.            v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
  1943.            v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
  1944.            break;
  1945.         case GL_MAP2_VERTEX_4:
  1946.            v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
  1947.            v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
  1948.            v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
  1949.            v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
  1950.            break;
  1951.         default:
  1952.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1953.      }
  1954.          break;
  1955.       default:
  1956.          gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
  1957.    }
  1958. }
  1959.  
  1960.  
  1961.  
  1962. void gl_EvalCoord1f(GLcontext* ctx, GLfloat u)
  1963. {
  1964.   GLfloat vertex[4];
  1965.   GLfloat normal[3];
  1966.   GLfloat fcolor[4];
  1967.   GLubyte icolor[4];
  1968.   const GLubyte *colorPtr;
  1969.   GLfloat texcoord[4];
  1970.   GLuint index;
  1971.   register GLfloat uu;
  1972.  
  1973.   /** Vertex **/
  1974.   if (ctx->Eval.Map1Vertex4) 
  1975.   {
  1976.      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
  1977.      uu = (u - map->u1) / (map->u2 - map->u1);
  1978.      horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
  1979.   }
  1980.   else if (ctx->Eval.Map1Vertex3) 
  1981.   {
  1982.      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
  1983.      uu = (u - map->u1) / (map->u2 - map->u1);
  1984.      horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
  1985.      vertex[3] = 1.0;
  1986.   }
  1987.  
  1988.   /** Color Index **/
  1989.   if (ctx->Eval.Map1Index) 
  1990.   {
  1991.      struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
  1992.      GLfloat findex;
  1993.      uu = (u - map->u1) / (map->u2 - map->u1);
  1994.      horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
  1995.      index = (GLuint) (GLint) findex;
  1996.   }
  1997.   else {
  1998.      index = ctx->Current.Index;
  1999.   }
  2000.  
  2001.   /** Color **/
  2002.   if (ctx->Eval.Map1Color4) {
  2003.      struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
  2004.      uu = (u - map->u1) / (map->u2 - map->u1);
  2005.      horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
  2006.      icolor[0] = (GLint) (fcolor[0] * 255.0F);
  2007.      icolor[1] = (GLint) (fcolor[1] * 255.0F);
  2008.      icolor[2] = (GLint) (fcolor[2] * 255.0F);
  2009.      icolor[3] = (GLint) (fcolor[3] * 255.0F);
  2010.      colorPtr = icolor;
  2011.   }
  2012.   else {
  2013.      colorPtr = ctx->Current.ByteColor;
  2014.   }
  2015.  
  2016.   /** Normal Vector **/
  2017.   if (ctx->Eval.Map1Normal) {
  2018.      struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
  2019.      uu = (u - map->u1) / (map->u2 - map->u1);
  2020.      horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
  2021.   }
  2022.   else {
  2023.     normal[0] = ctx->Current.Normal[0];
  2024.     normal[1] = ctx->Current.Normal[1];
  2025.     normal[2] = ctx->Current.Normal[2];
  2026.   }
  2027.  
  2028.   /** Texture Coordinates **/
  2029.   if (ctx->Eval.Map1TextureCoord4) {
  2030.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
  2031.      uu = (u - map->u1) / (map->u2 - map->u1);
  2032.      horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
  2033.   }
  2034.   else if (ctx->Eval.Map1TextureCoord3) {
  2035.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
  2036.      uu = (u - map->u1) / (map->u2 - map->u1);
  2037.      horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
  2038.      texcoord[3] = 1.0;
  2039.   }
  2040.   else if (ctx->Eval.Map1TextureCoord2) {
  2041.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
  2042.      uu = (u - map->u1) / (map->u2 - map->u1);
  2043.      horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
  2044.      texcoord[2] = 0.0;
  2045.      texcoord[3] = 1.0;
  2046.   }
  2047.   else if (ctx->Eval.Map1TextureCoord1) {
  2048.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
  2049.      uu = (u - map->u1) / (map->u2 - map->u1);
  2050.      horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
  2051.      texcoord[1] = 0.0;
  2052.      texcoord[2] = 0.0;
  2053.      texcoord[3] = 1.0;
  2054.   }
  2055.   else {
  2056.      texcoord[0] = ctx->Current.TexCoord[0];
  2057.      texcoord[1] = ctx->Current.TexCoord[1];
  2058.      texcoord[2] = ctx->Current.TexCoord[2];
  2059.      texcoord[3] = ctx->Current.TexCoord[3];
  2060.   }
  2061.   
  2062.   gl_eval_vertex( ctx, vertex, normal, colorPtr, index, texcoord );
  2063. }
  2064.  
  2065.  
  2066. void gl_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v )
  2067. {
  2068.    GLfloat vertex[4];
  2069.    GLfloat normal[3];
  2070.    GLfloat fcolor[4];
  2071.    GLubyte icolor[4];
  2072.    const GLubyte *colorPtr;
  2073.    GLfloat texcoord[4];
  2074.    GLuint index;
  2075.    register GLfloat uu, vv;
  2076.  
  2077. #define CROSS_PROD(n, u, v) \
  2078.   (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
  2079.   (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
  2080.   (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
  2081.  
  2082.    /** Vertex **/
  2083.    if(ctx->Eval.Map2Vertex4) {
  2084.       struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
  2085.       uu = (u - map->u1) / (map->u2 - map->u1);
  2086.       vv = (v - map->v1) / (map->v2 - map->v1);
  2087.  
  2088.       if (ctx->Eval.AutoNormal) {
  2089.          GLfloat du[4], dv[4];
  2090.  
  2091.          de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
  2092.                            map->Uorder, map->Vorder);
  2093.  
  2094.          CROSS_PROD(normal, du, dv);
  2095.          NORMALIZE_3FV(normal);
  2096.       }
  2097.       else {
  2098.          horner_bezier_surf(map->Points, vertex, uu, vv, 4,
  2099.                             map->Uorder, map->Vorder);
  2100.       }
  2101.    }
  2102.    else if (ctx->Eval.Map2Vertex3) {
  2103.       struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
  2104.       uu = (u - map->u1) / (map->u2 - map->u1);
  2105.       vv = (v - map->v1) / (map->v2 - map->v1);
  2106.       if (ctx->Eval.AutoNormal) {
  2107.          GLfloat du[3], dv[3];
  2108.          de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
  2109.                            map->Uorder, map->Vorder);
  2110.          CROSS_PROD(normal, du, dv);
  2111.          NORMALIZE_3FV(normal);
  2112.       }
  2113.       else {
  2114.          horner_bezier_surf(map->Points, vertex, uu, vv, 3,
  2115.                             map->Uorder, map->Vorder);
  2116.       }
  2117.       vertex[3] = 1.0;
  2118.    }
  2119. #undef CROSS_PROD
  2120.    
  2121.    /** Color Index **/
  2122.    if (ctx->Eval.Map2Index) {
  2123.       GLfloat findex;
  2124.       struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
  2125.       uu = (u - map->u1) / (map->u2 - map->u1);
  2126.       vv = (v - map->v1) / (map->v2 - map->v1);
  2127.       horner_bezier_surf(map->Points, &findex, uu, vv, 1,
  2128.                          map->Uorder, map->Vorder);
  2129.       index = (GLuint) (GLint) findex;
  2130.    }
  2131.    else {
  2132.       index = ctx->Current.Index;
  2133.    }
  2134.  
  2135.    /** Color **/
  2136.    if (ctx->Eval.Map2Color4) {
  2137.       struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
  2138.       uu = (u - map->u1) / (map->u2 - map->u1);
  2139.       vv = (v - map->v1) / (map->v2 - map->v1);
  2140.       horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
  2141.                          map->Uorder, map->Vorder);
  2142.       icolor[0] = (GLint) (fcolor[0] * 255.0F);
  2143.       icolor[1] = (GLint) (fcolor[1] * 255.0F);
  2144.       icolor[2] = (GLint) (fcolor[2] * 255.0F);
  2145.       icolor[3] = (GLint) (fcolor[3] * 255.0F);
  2146.       colorPtr = icolor;
  2147.    }
  2148.    else {
  2149.       colorPtr = ctx->Current.ByteColor;
  2150.    }
  2151.  
  2152.    /** Normal **/
  2153.    if (!ctx->Eval.AutoNormal
  2154.        || (!ctx->Eval.Map2Vertex3 && !ctx->Eval.Map2Vertex4)) {
  2155.       if (ctx->Eval.Map2Normal) {
  2156.          struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
  2157.          uu = (u - map->u1) / (map->u2 - map->u1);
  2158.          vv = (v - map->v1) / (map->v2 - map->v1);
  2159.          horner_bezier_surf(map->Points, normal, uu, vv, 3,
  2160.                             map->Uorder, map->Vorder);
  2161.       }
  2162.       else {
  2163.          normal[0] = ctx->Current.Normal[0];
  2164.          normal[1] = ctx->Current.Normal[1];
  2165.          normal[2] = ctx->Current.Normal[2];
  2166.       }
  2167.    }
  2168.  
  2169.    /** Texture Coordinates **/
  2170.    if (ctx->Eval.Map2TextureCoord4) {
  2171.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
  2172.       uu = (u - map->u1) / (map->u2 - map->u1);
  2173.       vv = (v - map->v1) / (map->v2 - map->v1);
  2174.       horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
  2175.                          map->Uorder, map->Vorder);
  2176.    }
  2177.    else if (ctx->Eval.Map2TextureCoord3) {
  2178.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
  2179.       uu = (u - map->u1) / (map->u2 - map->u1);
  2180.       vv = (v - map->v1) / (map->v2 - map->v1);
  2181.       horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
  2182.                          map->Uorder, map->Vorder);
  2183.      texcoord[3] = 1.0;
  2184.    }
  2185.    else if (ctx->Eval.Map2TextureCoord2) {
  2186.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
  2187.       uu = (u - map->u1) / (map->u2 - map->u1);
  2188.       vv = (v - map->v1) / (map->v2 - map->v1);
  2189.       horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
  2190.                          map->Uorder, map->Vorder);
  2191.      texcoord[2] = 0.0;
  2192.      texcoord[3] = 1.0;
  2193.    }
  2194.    else if (ctx->Eval.Map2TextureCoord1) {
  2195.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
  2196.       uu = (u - map->u1) / (map->u2 - map->u1);
  2197.       vv = (v - map->v1) / (map->v2 - map->v1);
  2198.       horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
  2199.                          map->Uorder, map->Vorder);
  2200.      texcoord[1] = 0.0;
  2201.      texcoord[2] = 0.0;
  2202.      texcoord[3] = 1.0;
  2203.    }
  2204.    else 
  2205.    {
  2206.      texcoord[0] = ctx->Current.TexCoord[0];
  2207.      texcoord[1] = ctx->Current.TexCoord[1];
  2208.      texcoord[2] = ctx->Current.TexCoord[2];
  2209.      texcoord[3] = ctx->Current.TexCoord[3];
  2210.    }
  2211.  
  2212.    gl_eval_vertex( ctx, vertex, normal, colorPtr, index, texcoord );
  2213. }
  2214.  
  2215.  
  2216. void gl_MapGrid1f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2 )
  2217. {
  2218.    if (INSIDE_BEGIN_END(ctx)) {
  2219.       gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid1f" );
  2220.       return;
  2221.    }
  2222.    if (un<1) {
  2223.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
  2224.       return;
  2225.    }
  2226.    ctx->Eval.MapGrid1un = un;
  2227.    ctx->Eval.MapGrid1u1 = u1;
  2228.    ctx->Eval.MapGrid1u2 = u2;
  2229. }
  2230.  
  2231.  
  2232. void gl_MapGrid2f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2,
  2233.           GLint vn, GLfloat v1, GLfloat v2 )
  2234. {
  2235.    if (INSIDE_BEGIN_END(ctx)) {
  2236.       gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid2f" );
  2237.       return;
  2238.    }
  2239.    if (un<1) {
  2240.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
  2241.       return;
  2242.    }
  2243.    if (vn<1) {
  2244.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
  2245.       return;
  2246.    }
  2247.    ctx->Eval.MapGrid2un = un;
  2248.    ctx->Eval.MapGrid2u1 = u1;
  2249.    ctx->Eval.MapGrid2u2 = u2;
  2250.    ctx->Eval.MapGrid2vn = vn;
  2251.    ctx->Eval.MapGrid2v1 = v1;
  2252.    ctx->Eval.MapGrid2v2 = v2;
  2253. }
  2254.  
  2255.  
  2256. void gl_EvalPoint1( GLcontext* ctx, GLint i )
  2257. {
  2258.    GLfloat u, du;
  2259.  
  2260.    if (i==0) {
  2261.       u = ctx->Eval.MapGrid1u1;
  2262.    }
  2263.    else if (i==ctx->Eval.MapGrid1un) {
  2264.       u = ctx->Eval.MapGrid1u2;
  2265.    }
  2266.    else {
  2267.       du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
  2268.          / (GLfloat) ctx->Eval.MapGrid1un;
  2269.       u = i * du + ctx->Eval.MapGrid1u1;
  2270.    }
  2271.    gl_EvalCoord1f( ctx, u );
  2272. }
  2273.  
  2274.  
  2275.  
  2276. void gl_EvalPoint2( GLcontext* ctx, GLint i, GLint j )
  2277. {
  2278.    GLfloat u, du;
  2279.    GLfloat v, dv;
  2280.  
  2281.    if (i==0) {
  2282.       u = ctx->Eval.MapGrid2u1;
  2283.    }
  2284.    else if (i==ctx->Eval.MapGrid2un) {
  2285.       u = ctx->Eval.MapGrid2u2;
  2286.    }
  2287.    else {
  2288.       du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
  2289.          / (GLfloat) ctx->Eval.MapGrid2un;
  2290.       u = i * du + ctx->Eval.MapGrid2u1;
  2291.    }
  2292.  
  2293.    if (j==0) {
  2294.       v = ctx->Eval.MapGrid2v1;
  2295.    }
  2296.    else if (j==ctx->Eval.MapGrid2vn) {
  2297.       v = ctx->Eval.MapGrid2v2;
  2298.    }
  2299.    else {
  2300.       dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
  2301.          / (GLfloat) ctx->Eval.MapGrid2vn;
  2302.       v = j * dv + ctx->Eval.MapGrid2v1;
  2303.    }
  2304.  
  2305.    gl_EvalCoord2f( ctx, u, v );
  2306. }
  2307.  
  2308.  
  2309.  
  2310. void gl_EvalMesh1( GLcontext* ctx, GLenum mode, GLint i1, GLint i2 )
  2311. {
  2312.    GLint i;
  2313.    GLfloat u, du;
  2314.    GLenum prim;
  2315.  
  2316.    if (INSIDE_BEGIN_END(ctx)) {
  2317.       gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
  2318.       return;
  2319.    }
  2320.  
  2321.    switch (mode) {
  2322.       case GL_POINT:
  2323.          prim = GL_POINTS;
  2324.          break;
  2325.       case GL_LINE:
  2326.          prim = GL_LINE_STRIP;
  2327.          break;
  2328.       default:
  2329.          gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
  2330.          return;
  2331.    }
  2332.  
  2333.    du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
  2334.       / (GLfloat) ctx->Eval.MapGrid1un;
  2335.  
  2336.    gl_Begin( ctx, prim );
  2337.    for (i=i1;i<=i2;i++) {
  2338.       if (i==0) {
  2339.          u = ctx->Eval.MapGrid1u1;
  2340.       }
  2341.       else if (i==ctx->Eval.MapGrid1un) {
  2342.          u = ctx->Eval.MapGrid1u2;
  2343.       }
  2344.       else {
  2345.          u = i * du + ctx->Eval.MapGrid1u1;
  2346.       }
  2347.       gl_EvalCoord1f( ctx, u );
  2348.    }
  2349.    gl_End(ctx);
  2350. }
  2351.  
  2352.  
  2353.  
  2354. void gl_EvalMesh2( GLcontext* ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  2355. {
  2356.     GLint i, j;
  2357.     GLfloat u, du, v, dv, v1, v2;
  2358.  
  2359.     if (INSIDE_BEGIN_END(ctx)) {
  2360.         gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
  2361.         return;
  2362.     }
  2363.  
  2364.     du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
  2365.         / (GLfloat) ctx->Eval.MapGrid2un;
  2366.     dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
  2367.         / (GLfloat) ctx->Eval.MapGrid2vn;
  2368.  
  2369. #define I_TO_U( I, U )                \
  2370.     if ((I)==0) {                   \
  2371.         U = ctx->Eval.MapGrid2u1;        \
  2372.     }                    \
  2373.     else if ((I)==ctx->Eval.MapGrid2un) {    \
  2374.         U = ctx->Eval.MapGrid2u2;        \
  2375.     }                    \
  2376.     else {                \
  2377.         U = (I) * du + ctx->Eval.MapGrid2u1;\
  2378.     }
  2379.  
  2380. #define J_TO_V( J, V )                \
  2381.     if ((J)==0) {            \
  2382.         V = ctx->Eval.MapGrid2v1;        \
  2383.     }                    \
  2384.     else if ((J)==ctx->Eval.MapGrid2vn) {    \
  2385.         V = ctx->Eval.MapGrid2v2;        \
  2386.     }                    \
  2387.     else {                \
  2388.         V = (J) * dv + ctx->Eval.MapGrid2v1;\
  2389.     }
  2390.  
  2391.     switch (mode) {
  2392.     case GL_POINT:
  2393.         gl_Begin( ctx, GL_POINTS );
  2394.         for (j=j1;j<=j2;j++) {
  2395.             J_TO_V( j, v );
  2396.             for (i=i1;i<=i2;i++) {
  2397.                 I_TO_U( i, u );
  2398.                 gl_EvalCoord2f( ctx, u, v );
  2399.             }
  2400.         }
  2401.         gl_End(ctx);
  2402.         break;
  2403.     case GL_LINE:
  2404.         for (j=j1;j<=j2;j++) {
  2405.             J_TO_V( j, v );
  2406.             gl_Begin( ctx, GL_LINE_STRIP );
  2407.             for (i=i1;i<=i2;i++) {
  2408.                 I_TO_U( i, u );
  2409.                 gl_EvalCoord2f( ctx, u, v );
  2410.             }
  2411.             gl_End(ctx);
  2412.         }
  2413.         for (i=i1;i<=i2;i++) {
  2414.             I_TO_U( i, u );
  2415.             gl_Begin( ctx, GL_LINE_STRIP );
  2416.             for (j=j1;j<=j2;j++) {
  2417.                 J_TO_V( j, v );
  2418.                 gl_EvalCoord2f( ctx, u, v );
  2419.             }
  2420.             gl_End(ctx);
  2421.         }
  2422.         break;
  2423.     case GL_FILL:
  2424.         for (j=j1;j<j2;j++) {
  2425.             /* NOTE: a quad strip can't be used because the four */
  2426.             /* can't be guaranteed to be coplanar! */
  2427.             gl_Begin( ctx, GL_TRIANGLE_STRIP );
  2428.             J_TO_V( j, v1 );
  2429.             J_TO_V( j+1, v2 );
  2430.             for (i=i1;i<=i2;i++) {
  2431.                 I_TO_U( i, u );
  2432.                 gl_EvalCoord2f( ctx, u, v1 );
  2433.                 gl_EvalCoord2f( ctx, u, v2 );
  2434.             }
  2435.             gl_End(ctx);
  2436.         }
  2437.         break;
  2438.     default:
  2439.         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
  2440.         return;
  2441.     }
  2442.  
  2443. #undef I_TO_U
  2444. #undef J_TO_V
  2445. }
  2446.  
  2447.